#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using namespace std;

// 单例模式
// 饿汉
// 想要mian函数之前就创建好-》全局对象无法调用构造-》静态对象-》类外定义——》调用构造
/*
class single
{
public:
    static single* get_case()//无this指针，并且无拷贝，返回地址
    {
        return &s;
    }
private:
    single (const single&)=delete;
    const single& operator=(const single&)=delete;
    single()//构造函数私有
    {
        cout<<"饿汉已构造"<<endl;
    }
    static single s;//唯一的对象（静态成员存在静态区main之前就创建好了，在类内创建属于类，可以调用私有成员）
};
single single::s;//静态成员类内申明类外定义

int main()
{
    // single<int>* s=single<int>::get_case();
    // single<int>::s;
    single* instance=single::get_case();

    return 0;
}
*/

// 懒汉
// 进入main函数以后才开始创建对象-->那就不能设为静态对象，要设置为静态指针--》再类外定义置空，写一个静态成员函数执行new方法，返回静态单例对象的指针
// class single
// {
// public:
//     static single *get_case() // 无this指针，并且无拷贝，返回地址
//     {
//         if (s == nullptr) // 保证只有一个对象被创建
//         {
//             s = new single();
//             return s;
//         }
//     }

// private:
//     single(const single &) = delete;
//     const single &operator=(const single &) = delete;
//     single() // 构造函数私有
//     {
//         cout << "懒汉已构造" << endl;
//     }
//     static single *s; // 唯一的对象（静态成员存在静态区main之前就创建好了.在类内创建属于类，可以调用私有成员）

//     static void del()
//     {
//         delete s;
//         cout << "释放单例懒汉指针" << endl;
//         s = nullptr;
//     }
//     class gc // 内部类，充当智能指针的功能
//     {
//     public:
//         gc()
//         {
//             cout << "构造gc" << endl;
//         }
//         ~gc()
//         {
//             del(); // 只能调用静态成员
//         }
//     };
//     static gc smartptr; // 如果不设为静态成员的话，就无法析构，因为gc对象是需要依靠single来析构的
// };
// single *single::s = nullptr; // 类外定义静态成员
// single::gc single::smartptr; // 类外定义静态成员
// int main()
// {
//     single *s = single::get_case();
// }

// 另一种懒汉的方式实现单例
// 直接在类的静态成员函数中直接创建一个单例对象
class single
{
    single(const single &) = delete;
    const single &operator=(const single &) = delete;

    single()
    {
        cout << "构造" << endl;
    }

public:
    static single &get_case() // 因为拷贝已禁用，只能引用返回单例对象，静态对象生命周期随程序
    {
        static single s; // 而且不会重复创建，整个程序就一份
        // C++11之后可以保证局部静态对象初始化是线程安全的，只初始化一次
        return s;
    }
};
int main()
{
    
    cout << &single::get_case() << endl; // 只能通过该方式直接使用
}
